This PR reduces excessive pipeline output by implementing ModularPipelines' native CommandLogging enum for DotNet operations, replacing the previous custom CliWrap extension approach based on feedback.

Problem

The TUnit pipeline was generating excessive output due to ModularPipelines streaming command output to console:

• Build operations: 6,643 lines of output
• Pack operations: 235 lines per project
• Test runs: Thousands of lines of build/execution details
• Total pipeline output often exceeded 24,000+ lines, making CI logs slow to load and difficult to navigate

Solution

Following feedback to use ModularPipelines' built-in logging controls instead of custom CliWrap extensions, I implemented CommandLogging enum configuration across all DotNet operations:

CommandLogging Configuration

// Before: Default logging streams all output
await context.DotNet().Run(new DotNetRunOptions {...}, cancellationToken);

// After: Selective logging suppresses verbose output while preserving errors
await context.DotNet().Run(new DotNetRunOptions 
{
    // ... other options
    CommandLogging = CommandLogging.Input | CommandLogging.Error | CommandLogging.Duration | CommandLogging.ExitCode
}, cancellationToken);

Comprehensive Coverage

Updated 17 pipeline modules to use CommandLogging configuration:

• TestBaseModule: Centralized configuration for all inherited test modules
• Individual modules: Direct CommandLogging configuration for Run, Test, Pack, Publish, New, and NuGet operations
• Selective suppression: Removes CommandLogging.Output flag to suppress verbose stdout while preserving error streams

Technical Implementation

The CommandLogging enum supports flags and provides granular control:

• Input (1): Log command input
• Output (2): Log command output (excluded to reduce verbosity)
• Error (4): Log error output (preserved for debugging)
• Duration (8): Log execution time (preserved for performance monitoring)
• ExitCode (16): Log exit codes (preserved for failure detection)

Configuration Input | Error | Duration | ExitCode provides optimal balance of reduced output while maintaining diagnostic capabilities.

Key Benefits

✅ Native ModularPipelines Integration: Uses built-in logging controls instead of custom CliWrap interception
✅ Comprehensive Coverage: All 17 pipeline modules configured with appropriate CommandLogging
✅ Preserved Error Visibility: Failed operations still display full diagnostic output via Error flag
✅ Minimal Code Impact: Single property addition per DotNet operation + using statements
✅ Performance Optimized: Leverages ModularPipelines' internal output control mechanisms

This approach provides the requested output reduction while maintaining full error visibility and following ModularPipelines' recommended patterns for logging control.

💬 Share your feedback on Copilot coding agent for the chance to win a $200 gift card! Click here to start the survey.